home *** CD-ROM | disk | FTP | other *** search
/ Power Programmierung 2 / Power-Programmierung CD 2 (Tewi)(1994).iso / gnu / gnulib / gnucdiff / difpatch.dos < prev    next >
Encoding:
Text File  |  1988-12-16  |  19.9 KB  |  824 lines
  1.  
  2. *** analyze.c    Mon Sep 26 23:57:10 1988
  3. --- diff/analyze.c    Tue Dec 06 10:38:50 1988
  4. ***************
  5. *** 116,119 ****
  6. --- 116,120 ----
  7.         bmin > dmin ? bd[--bmin - 1] = INT_MAX : ++bmin;
  8.         bmax < dmax ? bd[++bmax + 1] = INT_MAX : --bmax;
  9. + 
  10.         for (d = bmax; d >= bmin; d -= 2)
  11.       {
  12. ***************
  13. *** 387,392 ****
  14. --- 388,401 ----
  15.   
  16.           /* Cancel provisional discards at the end, and shrink the run.  */
  17. + #if    defined(MSC_BUG)
  18.           while (j > i && discards[j - 1] == 2)
  19.             discards[j - 1] = 0, --provisional;
  20. + #else
  21. +         {
  22. +             int index = j - 1;
  23. +           while (j > i && discards[index] == 2)
  24. +             discards[index] = 0, --provisional;
  25. +         }
  26. + #endif
  27.   
  28.           /* Now we have the length of a run of discardable lines
  29. ***************
  30. *** 652,658 ****
  31. --- 661,673 ----
  32.        If so, we know they are identical without actually reading them.  */
  33.   
  34. + #if !defined(MSDOS)
  35. +     /*
  36. +     ** since MSC always sets the inode and dev fields to zero under DOS
  37. +     ** this test will always think two files are the same.
  38. +     */
  39.     if (filevec[0].stat.st_ino == filevec[1].stat.st_ino
  40.         && filevec[0].stat.st_dev == filevec[1].stat.st_dev)
  41.       return 0;
  42. + #endif /* MSDOS */
  43.   
  44.     binary = read_files (filevec);
  45. ***************
  46. *** 664,670 ****
  47. --- 679,711 ----
  48.     if (binary)
  49.       {
  50. + #if !defined(MSDOS)
  51.         int differs = (filevec[0].buffered_chars != filevec[1].buffered_chars
  52.                || bcmp (filevec[0].buffer, filevec[1].buffer,
  53.                     filevec[1].buffered_chars));
  54. + #else
  55. +     int differs;
  56. +     if(filevec[0].buffered_chars != filevec[1].buffered_chars)
  57. +         differs = 1;
  58. +     else {
  59. +         /*
  60. +         ** we've got to do it in chunks because of our
  61. +         ** poor 16 bit processor
  62. +         */
  63. +         char huge *b0 = filevec[0].buffer,
  64. +               *b1 = filevec[1].buffer;
  65. +         long int count;
  66. +         unsigned int delta;
  67. +         count = filevec[0].buffered_chars;
  68. +         while(count > 0) {
  69. +             delta = (unsigned)(count > 65000 ? 65000 : count);
  70. +             if(bcmp(b0,b1,delta) != 0)
  71. +                 break;
  72. +             count -= delta;
  73. +             b0 += delta;
  74. +             b1 += delta;
  75. +         }
  76. +         differs = count != 0;
  77. +     }
  78. + #endif           
  79.         if (differs) 
  80.       message ("Binary files %s and %s differ\n",
  81. ***************
  82. *** 775,780 ****
  83. --- 816,826 ----
  84.     for (i = 0; i < 2; ++i)
  85.       {
  86. + #if !defined(MSDOS)
  87.         if (filevec[i].buffer != 0)
  88.       free (filevec[i].buffer);
  89. + #else    /* MSDOS */
  90. +       if (filevec[i].buffer != 0)
  91. +     hfree (filevec[i].buffer);
  92. + #endif
  93.         free (filevec[i].linbuf);
  94.       }
  95. *** context.c    Wed Sep 28 21:19:18 1988
  96. --- diff/context.c    Mon Dec 05 10:36:40 1988
  97. ***************
  98. *** 253,257 ****
  99.   
  100.         /* If the change is ignorable, mark it.  */
  101. !       script->ignore = (!deletes && !inserts);
  102.   
  103.         /* Advance to the following change.  */
  104. --- 253,257 ----
  105.   
  106.         /* If the change is ignorable, mark it.  */
  107. !       script->ignore = (char)(!deletes && !inserts);
  108.   
  109.         /* Advance to the following change.  */
  110. *** diff.c    Fri Oct 07 00:18:42 1988
  111. --- diff/diff.c    Tue Dec 06 10:25:02 1988
  112. ***************
  113. *** 68,72 ****
  114.   }
  115.   
  116. ! main (argc, argv)
  117.        int argc;
  118.        char *argv[];
  119. --- 68,72 ----
  120.   }
  121.   
  122. ! void main (argc, argv)
  123.        int argc;
  124.        char *argv[];
  125. ***************
  126. *** 301,304 ****
  127. --- 301,305 ----
  128.   }
  129.   
  130. + void
  131.   specify_style (style)
  132.        enum output_style style;
  133. ***************
  134. *** 383,387 ****
  135.       }
  136.       }
  137. ! 
  138.     /* See if the two named files are actually the same physical file.
  139.        If so, we know they are identical without actually reading them.  */
  140. --- 384,394 ----
  141.       }
  142.       }
  143. ! #if !defined(MSDOS)
  144. !     /*
  145. !     ** this stuff is real bad idea under MSDOS, at least for MSC 5.1
  146. !     ** because the st_ino and st_dev fields are not supported by
  147. !     ** MSDOS, and so stat sets them to zero; therefore
  148. !     ** this test always succeeds.
  149. !     */
  150.     /* See if the two named files are actually the same physical file.
  151.        If so, we know they are identical without actually reading them.  */
  152. ***************
  153. *** 395,398 ****
  154. --- 402,406 ----
  155.         goto done;
  156.       }
  157. + #endif    /* MSDOS */
  158.   
  159.     /* Open the files and record their descriptors.  */
  160. ***************
  161. *** 411,415 ****
  162.       {
  163.         char *filename = inf[i].name;
  164. ! 
  165.         inf[i].desc = open (filename, O_RDONLY, 0);
  166.         if (0 > inf[i].desc)
  167. --- 419,431 ----
  168.       {
  169.         char *filename = inf[i].name;
  170. ! #if !defined(MSDOS)
  171. !       inf[i].desc = open (filename, O_RDONLY, 0);
  172. !       if (0 > inf[i].desc)
  173. !         {
  174. !           perror_with_name (filename);
  175. !           errorcount = 1;
  176. !         }
  177. ! #else
  178. !     if(inf[i].dir_p == 0) {
  179.             inf[i].desc = open (filename, O_RDONLY, 0);
  180.             if (0 > inf[i].desc)
  181. ***************
  182. *** 418,421 ****
  183. --- 434,440 ----
  184.                 errorcount = 1;
  185.               }
  186. +         } else
  187. +             inf[i].desc = 0;
  188. + #endif    /* MSDOS */
  189.       }
  190.       }
  191. *** diff.h    Wed Oct 12 00:51:24 1988
  192. --- diff/diff.h    Mon Dec 05 10:40:14 1988
  193. ***************
  194. *** 23,27 ****
  195. --- 23,31 ----
  196.   #include <stdio.h>
  197.   #include <sys/types.h>
  198. + 
  199. + #if !defined(MSDOS)
  200.   #include <sys/file.h>
  201. + #endif    /* MSDOS */
  202. + 
  203.   #include <sys/stat.h>
  204.   
  205. ***************
  206. *** 28,32 ****
  207. --- 32,40 ----
  208.   #ifdef USG
  209.   #include <time.h>
  210. + 
  211. + #if !defined(MSDOS)
  212.   #include <dirent.h>
  213. + #endif /* MSDOS */
  214. + 
  215.   #include <fcntl.h>
  216.   #define direct dirent
  217. ***************
  218. *** 43,47 ****
  219. --- 51,57 ----
  220.   #define bzero(s,n)    memset((s),0,(n))
  221.   
  222. + #if !defined(MSDOS)
  223.   #define dup2(f,t)    (close(t),fcntl((f),F_DUPFD,(t)))
  224. + #endif
  225.   
  226.   #define vfork    fork
  227. ***************
  228. *** 50,57 ****
  229. --- 60,75 ----
  230.   #endif
  231.   
  232. + #ifdef MSDOS
  233. + #include <process.h>
  234. + #include <stdlib.h>
  235. + #endif /* MSDOS */
  236. + 
  237.   #include <errno.h>
  238. + 
  239. + #if !defined(MSDOS)
  240.   extern int      errno;
  241.   extern int      sys_nerr;
  242.   extern char    *sys_errlist[];
  243. + #endif
  244.   
  245.   #define    EOS        (0)
  246. ***************
  247. *** 59,64 ****
  248. --- 77,84 ----
  249.   #define TRUE        1
  250.   
  251. + #if !defined(min)
  252.   #define min(a,b) ((a) <= (b) ? (a) : (b))
  253.   #define max(a,b) ((a) >= (b) ? (a) : (b))
  254. + #endif /* MSDOS */
  255.   
  256.   #ifndef PR_FILE_NAME
  257. ***************
  258. *** 68,73 ****
  259. --- 88,97 ----
  260.   /* Support old-fashioned C compilers.  */
  261.   #if defined (__STDC__) || defined (__GNUC__)
  262. + #if !defined(MSDOS)
  263.   #include "limits.h"
  264.   #else
  265. + #include <limits.h>
  266. + #endif    /* MSDOS */
  267. + #else
  268.   #define INT_MAX 2147483647
  269.   #define CHAR_BIT 8
  270. ***************
  271. *** 74,79 ****
  272.   #endif
  273.   
  274.   /* Support old-fashioned C compilers.  */
  275. ! #if !defined (__STDC__) && !defined (__GNUC__)
  276.   #define const
  277.   #endif
  278. --- 98,117 ----
  279.   #endif
  280.   
  281. + #if defined(MSDOS)
  282. + #ifdef INT_MAX
  283. + #undef INT_MAX
  284. + #include <limits.h>
  285. + #endif
  286. + #if !defined(MAKING_PROTO_H)
  287. + #include "proto.h"
  288. + #endif
  289. + #include <malloc.h>
  290. + #include <io.h>
  291. + #include <memory.h>
  292. + extern int getopt(int nargc,char **nargv,char *ostr);
  293. + #endif
  294. + 
  295.   /* Support old-fashioned C compilers.  */
  296. ! #if !defined (__STDC__) && !defined (__GNUC__) || defined(MSDOS)
  297.   #define const
  298.   #endif
  299. ***************
  300. *** 215,223 ****
  301.   
  302.       /* Buffer in which text of file is read.  */
  303.       char *        buffer;
  304.       /* Allocated size of buffer.  */
  305.       int            bufsize;
  306.       /* Number of valid characters now in the buffer. */
  307. !     int            buffered_chars;
  308.   
  309.       /* Array of data on analyzed lines of this chunk of this file.  */
  310. --- 253,273 ----
  311.   
  312.       /* Buffer in which text of file is read.  */
  313. + #if !defined(MSDOS)
  314.       char *        buffer;
  315. + 
  316.       /* Allocated size of buffer.  */
  317.       int            bufsize;
  318. + 
  319. +     /* Number of valid characters now in the buffer. */
  320. +     long int            buffered_chars;
  321. + #else    /* MSDOS */
  322. +     char huge *buffer;
  323. + 
  324. +     /* Allocated size of buffer.  */
  325. +     long int        bufsize;
  326. + 
  327.       /* Number of valid characters now in the buffer. */
  328. !     long int            buffered_chars;
  329. ! #endif    /* MSDOS */
  330.   
  331.       /* Array of data on analyzed lines of this chunk of this file.  */
  332. ***************
  333. *** 315,316 ****
  334. --- 365,367 ----
  335.   void message ();
  336.   void print_message_queue ();
  337. + 
  338. *** dir.c    Tue Sep 20 13:32:58 1988
  339. --- diff/dir.c    Tue Dec 06 11:34:58 1988
  340. ***************
  341. *** 32,35 ****
  342. --- 32,94 ----
  343.   };
  344.   
  345. + #if defined(MSDOS)
  346. + /*
  347. + ** due to difference of opinion btw gnu and microsoft about what
  348. + ** const means, const is defined away in diff.h, which causes warnings
  349. + ** when compiling the headers.  This ugliness is avoided here.
  350. + */
  351. + #ifdef const
  352. + #undef const
  353. + #endif
  354. + #include <string.h>
  355. + #include <dos.h>
  356. + 
  357. + struct direct {
  358. +     char d_name[14];
  359. + };
  360. + 
  361. + typedef struct _dir {
  362. +     int first;
  363. +     struct find_t dta;
  364. +     struct direct current;
  365. + } DIR;
  366. + 
  367. + 
  368. + DIR *
  369. + opendir(char *name) {
  370. +     char localname[65];
  371. +     DIR *rval = malloc(sizeof(DIR));
  372. +     strcpy(localname,name);
  373. +     strcat(localname,"/*.*");
  374. +     if(rval == NULL ||
  375. +         _dos_findfirst(localname,_A_NORMAL|_A_SUBDIR,&rval->dta) != 0)
  376. +         return NULL;
  377. +     rval->first = 1;
  378. +     return rval;
  379. + }
  380. + 
  381. + void
  382. + closedir(DIR *x) {
  383. +     free(x);
  384. + }
  385. + 
  386. + struct direct *
  387. + readdir(DIR *thisdir) {
  388. +     /*
  389. +     ** first time through, we don't need to look for a file
  390. +     */
  391. +     if(!thisdir->first) {
  392. +         if(_dos_findnext(&thisdir->dta) != 0)
  393. +             return NULL;
  394. +     } else
  395. +         thisdir->first = 0;
  396. +     strncpy(thisdir->current.d_name,thisdir->dta.name,13);
  397. +     thisdir->current.d_name[13] = '\0';
  398. +     strlwr(thisdir->current.d_name);
  399. +     return &thisdir->current;
  400. + }
  401. +         
  402. + #endif /* MSDOS */
  403. + 
  404.   static struct dirdata
  405.   dir_sort (dirname)
  406. ***************
  407. *** 55,59 ****
  408.       {
  409.         pfatal_with_name (dirname);
  410. !       return;
  411.       }
  412.   
  413. --- 114,118 ----
  414.       {
  415.         pfatal_with_name (dirname);
  416. !       return dirdata;
  417.       }
  418.   
  419. ***************
  420. *** 124,128 ****
  421. --- 183,195 ----
  422.   diff_dirs (name1, name2, handle_file, depth)
  423.        char *name1, *name2;
  424. + #if !defined(MSDOS)
  425.        int (*handle_file) ();
  426. + #else
  427. +     /* sorry, rms, I can't live with the assumption that
  428. +     ** sizeof(char *) == sizeof(int)
  429. +     */
  430. +     int (*handle_file)(char *dir0,char *name0,
  431. +         char *dir1,char *name1,int depth);
  432. + #endif
  433.   {
  434.     struct dirdata data1, data2;
  435. ***************
  436. *** 176,180 ****
  437.       {
  438.         /* Next filename in dir 1 is less; that is a file in dir 1 only.  */
  439. !       v1 = handle_file (name1, data1.files[i1], name2, 0, depth + 1);
  440.         i1++;
  441.       }
  442. --- 243,248 ----
  443.       {
  444.         /* Next filename in dir 1 is less; that is a file in dir 1 only.  */
  445. !       v1 = handle_file (name1, data1.files[i1], name2, (char *)0,
  446. !           depth + 1);
  447.         i1++;
  448.       }
  449. ***************
  450. *** 182,186 ****
  451.       {
  452.         /* Next filename in dir 2 is less; that is a file in dir 2 only.  */
  453. !       v1 = handle_file (name1, 0, name2, data2.files[i2], depth + 1);
  454.         i2++;
  455.       }
  456. --- 250,255 ----
  457.       {
  458.         /* Next filename in dir 2 is less; that is a file in dir 2 only.  */
  459. !       v1 = handle_file (name1, (char *)0, name2, data2.files[i2],
  460. !           depth + 1);
  461.         i2++;
  462.       }
  463. *** io.c    Mon Sep 26 22:27:28 1988
  464. --- diff/io.c    Tue Dec 06 11:19:24 1988
  465. ***************
  466. *** 22,27 ****
  467. --- 22,31 ----
  468.   
  469.   /* Rotate a value n bits to the left. */
  470. + #if !defined(MSDOS)
  471.   #define UINT_BIT (sizeof (unsigned) * CHAR_BIT)
  472.   #define ROL(v, n) ((v) << (n) | (v) >> UINT_BIT - (n))
  473. + #else
  474. + #define ROL(v,n)  ((v) << (n) | (v) >> (sizeof(v) * CHAR_BIT) - (n))
  475. + #endif
  476.   
  477.   /* Given a hash value and a new character, return a new hash value. */
  478. ***************
  479. *** 62,65 ****
  480. --- 66,70 ----
  481.         current->buffer = 0;
  482.       }
  483. + #if !defined(MSDOS)     
  484.     /* If it's a regular file, we can just get the size out of the stat
  485.        block and slurp it in all at once. */
  486. ***************
  487. *** 70,76 ****
  488. --- 75,97 ----
  489.         current->buffered_chars
  490.       = read (current->desc, current->buffer, current->bufsize);
  491. + #else    /* MSDOS */
  492. +   else {
  493. +       current->bufsize = current->stat.st_size + 1;
  494. +     if((current->buffer = 
  495. +         (char huge *)halloc(current->bufsize,sizeof(char))) == NULL)
  496. +         fatal("virtual memory exhausted");
  497. +     {
  498. +         int count;
  499. +         current->buffered_chars = 0;
  500. +         while((count = read(current->desc,
  501. +             current->buffer+current->buffered_chars,
  502. +                 32000)) > 0)
  503. +             current->buffered_chars += count;
  504. +     }
  505. + #endif    /* MSDOS */
  506.         if (current->buffered_chars < 0)
  507.       pfatal_with_name (current->name);
  508.       }
  509. + #if !defined(MSDOS)
  510.     else
  511.       {
  512. ***************
  513. *** 97,100 ****
  514. --- 118,122 ----
  515.       pfatal_with_name (current->name);
  516.       }
  517. + #endif /* MSDOS */
  518.     
  519.     /* Check first part of file to see if it's a binary file.  */
  520. ***************
  521. *** 129,135 ****
  522. --- 151,167 ----
  523.   
  524.     /* Attempt to get a good initial guess as to the number of lines. */
  525. + #if !defined(MSDOS)
  526.     current->linbufsize = current->buffered_chars / 50 + 5;
  527.     current->linbuf
  528.       = (struct line_def *) xmalloc (current->linbufsize * sizeof (struct line_def));
  529. + #else
  530. +     long int buffersize;
  531. +     current->linbufsize = (int)
  532. +         (buffersize = (long int)(current->buffered_chars / 50 + 5));
  533. +     buffersize *= sizeof(struct line_def);
  534. +     if(buffersize > 65535L)
  535. +         fatal("Too many lines to compare");
  536. +     current->linbuf = (struct line_def *) xmalloc((size_t)buffersize);
  537. + #endif
  538.   
  539.     if (function_regexp)
  540. ***************
  541. *** 291,296 ****
  542.     int lines;
  543.     /* Number of bytes left to scan.  */
  544.     int bytes = min (filevec[0].buffered_chars, filevec[1].buffered_chars);
  545. ! 
  546.     /* Find identical prefix.  */
  547.   
  548. --- 323,331 ----
  549.     int lines;
  550.     /* Number of bytes left to scan.  */
  551. + #if !defined(MSDOS)
  552.     int bytes = min (filevec[0].buffered_chars, filevec[1].buffered_chars);
  553. ! #else
  554. !   long int bytes = min (filevec[0].buffered_chars, filevec[1].buffered_chars);
  555. ! #endif
  556.     /* Find identical prefix.  */
  557.   
  558. ***************
  559. *** 388,391 ****
  560. --- 423,427 ----
  561.     32749,
  562.     65521,
  563. + #if !defined MSDOS
  564.     131071,
  565.     262139,
  566. ***************
  567. *** 399,402 ****
  568. --- 435,439 ----
  569.     67108859,            /* Preposterously large . . . */
  570.     -1
  571. + #endif
  572.   };
  573.   
  574. ***************
  575. *** 410,414 ****
  576.        int n;
  577.   {
  578. !   int bucket = current->linbuf[n].hash % nbuckets;
  579.     struct equivclass *b = buckets[bucket], *p = NULL;
  580.   
  581. --- 447,451 ----
  582.        int n;
  583.   {
  584. !   int bucket = (int)(current->linbuf[n].hash % nbuckets);
  585.     struct equivclass *b = buckets[bucket], *p = NULL;
  586.   
  587. *** regex.c    Sat Oct 08 01:16:56 1988
  588. --- diff/regex.c    Thu Dec 08 08:20:48 1988
  589. ***************
  590. *** 136,139 ****
  591. --- 136,145 ----
  592.   #endif
  593.   
  594. + #ifdef MSDOS
  595. + #include <memory.h>
  596. + #include <malloc.h>
  597. + #include "diff.h"
  598. + #endif
  599. + 
  600.   /*
  601.    * Define the syntax stuff, so we can do the \<...\> things.
  602. ***************
  603. *** 188,192 ****
  604.   #ifndef NFAILURES
  605.   #define NFAILURES 80
  606. ! #endif NFAILURES
  607.   
  608.   /* width of a byte in bits */
  609. --- 194,198 ----
  610.   #ifndef NFAILURES
  611.   #define NFAILURES 80
  612. ! #endif /* NFAILURES */
  613.   
  614.   /* width of a byte in bits */
  615. ***************
  616. *** 246,249 ****
  617. --- 252,256 ----
  618.   #define PATUNFETCH p--
  619.   
  620. + #if !defined(MSDOS)
  621.   #define EXTEND_BUFFER \
  622.     { char *old_buffer = bufp->buffer; \
  623. ***************
  624. *** 263,268 ****
  625.         pending_exact += c; \
  626.     }
  627. ! 
  628. ! static int store_jump (), insert_jump ();
  629.   
  630.   char *
  631. --- 270,293 ----
  632.         pending_exact += c; \
  633.     }
  634. ! #else
  635. ! #define EXTEND_BUFFER \
  636. !   { char *old_buffer = bufp->buffer; \
  637. !     if (bufp->allocated == (1<<15)) goto too_big; \
  638. !     bufp->allocated *= 2; \
  639. !     if (bufp->allocated > (1<<15)) bufp->allocated = (1<<15); \
  640. !     if (!(bufp->buffer = (char *) realloc (bufp->buffer, bufp->allocated))) \
  641. !       goto memory_exhausted; \
  642. !     c = bufp->buffer - old_buffer; \
  643. !     b += c; \
  644. !     if (fixup_jump) \
  645. !       fixup_jump += c; \
  646. !     if (laststart) \
  647. !       laststart += c; \
  648. !     begalt += c; \
  649. !     if (pending_exact) \
  650. !       pending_exact += c; \
  651. !   }
  652. ! #endif
  653. ! static void store_jump (), insert_jump ();
  654.   
  655.   char *
  656. ***************
  657. *** 345,350 ****
  658. --- 370,379 ----
  659.         else
  660.       /* Caller did not allocate a buffer.  Do it for him */
  661. + #if !defined(MSDOS)
  662.       bufp->buffer = (char *) malloc (28);
  663.         if (!bufp->buffer) goto memory_exhausted;
  664. + #else
  665. +     bufp->buffer = (char *) xmalloc(28);
  666. + #endif
  667.         begalt = b = bufp->buffer;
  668.       }
  669. ***************
  670. *** 746,750 ****
  671.     `opcode' is the opcode to store. */
  672.   
  673. ! static int
  674.   store_jump (from, opcode, to)
  675.        char *from, *to;
  676. --- 775,779 ----
  677.     `opcode' is the opcode to store. */
  678.   
  679. ! static void
  680.   store_jump (from, opcode, to)
  681.        char *from, *to;
  682. ***************
  683. *** 752,757 ****
  684.   {
  685.     from[0] = opcode;
  686. !   from[1] = (to - (from + 3)) & 0377;
  687. !   from[2] = (to - (from + 3)) >> 8;
  688.   }
  689.   
  690. --- 781,786 ----
  691.   {
  692.     from[0] = opcode;
  693. !   from[1] = (char)((to - (from + 3)) & 0377);
  694. !   from[2] = (char)((to - (from + 3)) >> 8);
  695.   }
  696.   
  697. ***************
  698. *** 763,767 ****
  699.      If you call this function, you must zero out pending_exact.  */
  700.   
  701. ! static int
  702.   insert_jump (op, from, to, current_end)
  703.        char op;
  704. --- 792,796 ----
  705.      If you call this function, you must zero out pending_exact.  */
  706.   
  707. ! static void
  708.   insert_jump (op, from, to, current_end)
  709.        char op;
  710. ***************
  711. *** 1274,1278 ****
  712.       case start_memory:
  713.         regstart[*p] = d;
  714. !        regstart_seg1[*p++] = (dend == end_match_1);
  715.         break;
  716.   
  717. --- 1303,1307 ----
  718.       case start_memory:
  719.         regstart[*p] = d;
  720. !        regstart_seg1[*p++] = (unsigned char)(dend == end_match_1);
  721.         break;
  722.   
  723. ***************
  724. *** 1279,1283 ****
  725.       case stop_memory:
  726.         regend[*p] = d;
  727. !        regend_seg1[*p++] = (dend == end_match_1);
  728.         break;
  729.   
  730. --- 1308,1312 ----
  731.       case stop_memory:
  732.         regend[*p] = d;
  733. !        regend_seg1[*p++] = (unsigned char)(dend == end_match_1);
  734.         break;
  735.   
  736. ***************
  737. *** 1424,1428 ****
  738.           /* p1[0] ... p1[2] are an on_failure_jump.
  739.              Examine what follows that */
  740. !         if (p1[3] == (unsigned char) exactn && p1[5] != c)
  741.             p[-3] = (unsigned char) finalize_jump;
  742.           else if (p1[3] == (unsigned char) charset
  743. --- 1453,1457 ----
  744.           /* p1[0] ... p1[2] are an on_failure_jump.
  745.              Examine what follows that */
  746. !         if (p1[3] == (char) exactn && p1[5] != (char)c)
  747.             p[-3] = (unsigned char) finalize_jump;
  748.           else if (p1[3] == (unsigned char) charset
  749. ***************
  750. *** 1661,1669 ****
  751.     if (!re_comp_buf.buffer)
  752.       {
  753.         if (!(re_comp_buf.buffer = (char *) malloc (200)))
  754.       return "Memory exhausted";
  755. -       re_comp_buf.allocated = 200;
  756.         if (!(re_comp_buf.fastmap = (char *) malloc (1 << BYTEWIDTH)))
  757.       return "Memory exhausted";
  758.       }
  759.     return re_compile_pattern (s, strlen (s), &re_comp_buf);
  760. --- 1690,1703 ----
  761.     if (!re_comp_buf.buffer)
  762.       {
  763. + #if !defined(MSDOS)
  764.         if (!(re_comp_buf.buffer = (char *) malloc (200)))
  765.       return "Memory exhausted";
  766.         if (!(re_comp_buf.fastmap = (char *) malloc (1 << BYTEWIDTH)))
  767.       return "Memory exhausted";
  768. + #else
  769. +     re_comp_buf.buffer = (char *) xmalloc(200);
  770. +     re_comp_buf.fastmap = (char *) xmalloc(1 << BYTEWIDTH);
  771. + #endif
  772. +       re_comp_buf.allocated = 200;
  773.       }
  774.     return re_compile_pattern (s, strlen (s), &re_comp_buf);
  775. *** util.c    Fri Sep 30 11:04:10 1988
  776. --- diff/util.c    Mon Dec 05 10:36:40 1988
  777. ***************
  778. *** 131,134 ****
  779. --- 131,135 ----
  780.     strcat (name, name1);
  781.   
  782. + #if !defined(MSDOS)
  783.     if (paginate_flag)
  784.       {
  785. ***************
  786. *** 163,166 ****
  787. --- 164,168 ----
  788.       }
  789.     else
  790. + #endif
  791.       {
  792.   
  793. ***************
  794. *** 187,191 ****
  795. --- 189,195 ----
  796.       {
  797.         fclose (outfile);
  798. + #if !defined(MSDOS)
  799.         wait (0);
  800. + #endif
  801.       }
  802.   }
  803. ***************
  804. *** 222,226 ****
  805.   
  806.     /* Undo the alteration.  */
  807. !   s1->text[s1->length] = savechar;
  808.   
  809.     /* If the comparison stopped at the alteration,
  810. --- 226,230 ----
  811.   
  812.     /* Undo the alteration.  */
  813. !   s1->text[s1->length] = (char) savechar;
  814.   
  815.     /* If the comparison stopped at the alteration,
  816. ***************
  817. *** 617,620 ****
  818. --- 621,625 ----
  819.   }
  820.   
  821. + void
  822.   debug_script (sp)
  823.        struct change *sp;
  824.